spacepaste

Paste details

reply | raw

  1.  
  2. #define F_CPU 8000000UL
  4. #include <avr/io.h>
  5. #include <stdio.h>
  6. #include <inttypes.h>
  7. #include <stdint.h>
  8. #include <avr/pgmspace.h>
  9. #include <avr/interrupt.h>
  10. #include <util/delay.h>
  11. #include <util/atomic.h>
  12. #include <avr/wdt.h>
  14. #define BAUDRATE 9600
  16. #define NTCBETA 3380
  17. #define NTCRES 10000
  18. #define NTCFIXEDRES 10000
  20. #define ONTEMP 4.0 // °C
  21. #define OFFTEMP 2.0 // °C
  23. #define POWERONDELAY 5 // sec
  24. #define ONTIME 60 // sec
  25. #define OFFTIME 180 // sec
  28. //////////////////////////////////////////////////////////////////////////////////////////////////////////
  29. // attiny48 //
  30. // pins //
  31. // 1 : PB5 reset, ADC0 //
  32. // 2 : PB3 ADC3 / RELAY //
  33. // 3 : PB4 ADC2 / CAP //
  34. // 4 : gnd //
  35. // 5 : PB0 Mosi, AREF //
  36. // 6 : PB1 Miso / TX //
  37. // 7 : PB2 SCK, ADC1 / NTC //
  38. // 8 : VCC //
  39. // //
  40. // VCC -> 10k -> NTC -> GND //
  41. // NTC: NTSD1XH103FPB40 https://media.digikey.com/pdf/Data%20Sheets/Murata%20PDFs/NTSD1%20Spec.pdf //
  42. // Beta: 3380 //
  43. //////////////////////////////////////////////////////////////////////////////////////////////////////////
  46. #define RELAYPIN PINB
  47. #define RELAYDDR DDRB
  48. #define RELAYPORT PORTB
  49. #define RELAYBIT 3
  51. #define CAPPIN PINB
  52. #define CAPDDR DDRB
  53. #define CAPPORT PORTB
  54. #define CAPBIT 4
  56. #define NTCPIN PINB
  57. #define NTCPORT PORTB
  58. #define NTCDDR DDRB
  59. #define NTCMUX 1
  60. #define NTCBIT 2
  62. #define UARTTXPIN PINB
  63. #define UARTTXPORT PORTB
  64. #define UARTTXDDR DDRB
  65. #define UARTTXBIT 1
  67. //////////////////////////////////
  68. // Do not edit bellow this line //
  69. //////////////////////////////////
  72. volatile uint32_t timeSecs = 68300;
  73. volatile uint32_t timeCycles = 0;
  74. volatile uint8_t status = 0;
  75. volatile uint16_t timeStatus = 0;
  76. volatile float temperature = 0.0;
  80. void usart_bitdelay() {
  81. _delay_us(1000000/BAUDRATE); // 1e6 us / baudrate
  82. }
  84. void usart_putchar(char data) {
  85. // 0 start, LSB...MSB, 2 stop
  86. uint8_t i;
  88. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  89. // start bit, 0
  90. UARTTXPORT &= ~(1 << UARTTXBIT);
  91. usart_bitdelay();
  93. // 8 data bits
  94. for (i = 8; i != 0; i--) {
  95. if (data & 0x01) {
  96. // 1
  97. UARTTXPORT |= (1 << UARTTXBIT);
  98. } else {
  99. // 0
  100. UARTTXPORT &= ~(1 << UARTTXBIT);
  101. }
  102. data >>= 1;
  103. usart_bitdelay();
  104. }
  107. // stop bit, 1
  108. UARTTXPORT |= (1 << UARTTXBIT);
  109. usart_bitdelay();
  110. usart_bitdelay();
  111. }
  112. }
  114. static FILE mystdout = FDEV_SETUP_STREAM(usart_putchar, NULL, _FDEV_SETUP_WRITE);
  116. void printData() {
  117. uint32_t lsecs;
  118. uint16_t lhours;
  119. uint8_t lmins;
  121. uint8_t lstatus;
  122. uint16_t ltstatus;
  124. float ltemp;
  126. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  127. lsecs = timeSecs;
  128. lstatus = status;
  129. ltstatus = timeStatus;
  130. ltemp = temperature;
  131. };
  133. lhours = lsecs / (uint32_t)3600;
  134. lsecs = lsecs - (lhours * (uint32_t)3600);
  136. lmins = lsecs / (uint32_t)60;
  137. lsecs = lsecs - (lmins * (uint32_t)60);
  139. printf_P(PSTR("% 5u:%02u:%02u "), lhours, lmins, lsecs);
  141. printf_P(PSTR("Temperature: % 6.2f°C Status: %d: "), ltemp, lstatus);
  142. if (lstatus == 0) {
  143. printf_P(PSTR("RCLockout "));
  144. } else if (lstatus == 1) {
  145. printf_P(PSTR("PowerOnDelay"));
  146. } else if (lstatus == 2) {
  147. printf_P(PSTR("Off "));
  148. } else if (lstatus == 3) {
  149. printf_P(PSTR("OffDelay "));
  150. } else if (lstatus == 4) {
  151. printf_P(PSTR("On "));
  152. } else if (lstatus == 5) {
  153. printf_P(PSTR("OnDelay "));
  154. }
  155. printf_P(PSTR(" Since: %5u secs Reset: "), ltstatus);
  156. if (MCUSR & (1<<WDRF)) { printf_P(PSTR("Watchdog")); }
  157. if (MCUSR & (1<<BORF)) { printf_P(PSTR("Brownout")); }
  158. if (MCUSR & (1<<EXTRF)) { printf_P(PSTR("External")); }
  159. if ( ! ((MCUSR & (1<<WDRF)) | (MCUSR & (1<<BORF)) | (MCUSR & (1<<EXTRF)) | (MCUSR & (1<<PORF)))) {
  160. printf_P(PSTR("None"));
  161. }
  162. printf_P(PSTR("\r\n"));
  163. }
  166. void relay(uint8_t state) {
  167. if (state == 0) {
  168. RELAYPORT &= ~(1<<RELAYBIT);
  169. } else if (state == 1) {
  170. RELAYPORT |= (1<<RELAYBIT);
  171. }
  172. }
  175. void calculateTemperature() {
  176. uint16_t adc = 0;
  177. uint8_t loop;
  178. float resistance;
  180. // sample and discard first sample
  181. ADCSRA |= (1<<ADSC);
  182. while (ADCSRA & (1<<ADSC));
  184. // oversample, 16
  185. for (loop = 0; loop < 16; loop++) {
  186. ADCSRA |= (1<<ADSC);
  187. while (ADCSRA & (1<<ADSC));
  188. adc += ADC;
  189. }
  191. // vvv due to oversampling
  192. resistance = ((float)adc * (float)NTCFIXEDRES) / ((1024*16)-adc);
  195. // 1/T0 1 / B R R25 K->C
  196. temperature = 1.0 / ( (1.0/298.15) + (1.0/(float)NTCBETA) * log(resistance / (float)NTCRES) ) - 273.15;
  197. }
  199. int main(void) {
  200. uint32_t ltime = 0;
  202. // set up watchdog timer
  203. wdt_enable(WDTO_8S);
  206. // set relay pin to output, set to off
  207. RELAYDDR |= (1<<RELAYBIT);
  208. relay(0);
  210. // set capacitor pin to input with pullup
  211. CAPDDR &= ~(1<<CAPBIT);
  212. CAPPORT |= (1<<CAPBIT);
  214. // set adc
  215. // attiny85 datasheet recommand 50-200kHz for maximum resolution
  216. // reference of 000 set to VCC, default to 000
  217. // ADMUX |= (1<<REFS0); // external ref
  218. ADMUX |= NTCMUX;
  219. // prescaller /128 = 62.5k@8MHz = 111
  220. ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0);
  222. // set timer0
  223. TCCR0B |= (1<<CS02) | (1<<CS00); // /1024 prescalling
  224. TIMSK |= (1<<TOIE0); // overflow interrupt enable
  226. // set uart
  227. UARTTXDDR |= (1<<UARTTXBIT);
  228. UARTTXPORT |= (1<<UARTTXBIT);
  229. stdout = &mystdout;
  232. printf_P(PSTR("\r\n"));
  233. printf_P(PSTR("Reset! \r\n"));
  235. // turn on interrupts
  236. sei();
  238. // look if the power reset flag is set, if so reset the reset sources
  239. if (MCUSR & (1<<PORF)) {
  240. MCUSR &= ~((1<<WDRF) | (1<<BORF) | (1<<EXTRF) | (1<<PORF));
  241. }
  244. // Main loop
  245. while(1) {
  246. // wait for a second to pass
  247. while (ltime == timeSecs);
  248. ltime = timeSecs;
  250. calculateTemperature();
  252. if (status == 0) {
  253. // lock out
  254. // check for cap
  255. if (CAPPIN & (1<<CAPBIT)) {
  256. // cap is discharged, release lockout
  257. status = 1;
  258. }
  259. } else if (status == 1) {
  260. // minimum poweron delay
  261. if (timeStatus >= POWERONDELAY) {
  262. status = 2;
  263. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  264. timeStatus = 0;
  265. }
  266. }
  267. } else if (status == 2) {
  268. // Off
  269. relay(0);
  270. if (temperature >= ONTEMP) {
  271. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  272. timeStatus = 0;
  273. }
  274. status = 5;
  275. }
  276. } else if (status == 3) {
  277. // Off with delay
  278. relay(0);
  279. if (timeStatus >= OFFTIME) {
  280. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  281. timeStatus = 0;
  282. }
  283. status = 2;
  284. }
  286. } else if (status == 4) {
  287. // On
  288. relay(1);
  289. if (temperature <= OFFTEMP) {
  290. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  291. timeStatus = 0;
  292. }
  293. status = 3;
  294. }
  295. } else if (status == 5) {
  296. // On with delay
  297. relay(1);
  298. if (timeStatus >= ONTIME) {
  299. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  300. timeStatus = 0;
  301. }
  302. status = 4;
  303. }
  304. }
  306. printData();
  307. wdt_reset();
  308. };
  310. return(0);
  311. }
  314. ISR(TIM0_OVF_vect) {
  315. // time keeping
  316. timeCycles += 262144; // 8 bits timer with /1024 prescaller
  317. if (timeCycles >= F_CPU) {
  318. timeCycles -= F_CPU;
  319. timeSecs++;
  320. timeStatus++;
  321. }
  323. }
  324.  
Powered by spacepaste. Paste removal.